import { projectApi, taskApi, announcementApi } from '@/api/project'
import { ElMessage } from 'element-plus'

/**
 * API连接测试工具
 */
export class ApiTester {
  private static instance: ApiTester

  private constructor() {}

  public static getInstance(): ApiTester {
    if (!ApiTester.instance) {
      ApiTester.instance = new ApiTester()
    }
    return ApiTester.instance
  }

  /**
   * 测试项目API连接
   */
  public async testProjectApi(teamId: number): Promise<boolean> {
    try {
      console.log('🔍 测试项目API连接...')
      
      // 测试获取团队项目列表
      const response = await projectApi.getTeamProjects(teamId)
      
      if (response.code === 200) {
        console.log('✅ 项目API连接成功', response)
        ElMessage.success('项目API连接成功')
        return true
      } else {
        console.error('❌ 项目API返回错误:', response)
        ElMessage.error(`项目API错误: ${response.message}`)
        return false
      }
    } catch (error: any) {
      console.error('❌ 项目API连接失败:', error)
      ElMessage.error(`项目API连接失败: ${error.message}`)
      return false
    }
  }

  /**
   * 测试任务API连接
   */
  public async testTaskApi(projectId: number): Promise<boolean> {
    try {
      console.log('🔍 测试任务API连接...')
      
      // 测试获取项目任务列表
      const response = await taskApi.getProjectTasks(projectId)
      
      if (response.code === 200) {
        console.log('✅ 任务API连接成功', response)
        ElMessage.success('任务API连接成功')
        return true
      } else {
        console.error('❌ 任务API返回错误:', response)
        ElMessage.error(`任务API错误: ${response.message}`)
        return false
      }
    } catch (error: any) {
      console.error('❌ 任务API连接失败:', error)
      ElMessage.error(`任务API连接失败: ${error.message}`)
      return false
    }
  }

  /**
   * 测试公告API连接
   */
  public async testAnnouncementApi(projectId: number): Promise<boolean> {
    try {
      console.log('🔍 测试公告API连接...')
      
      // 测试获取项目公告列表
      const response = await announcementApi.getProjectAnnouncements(projectId)
      
      if (response.code === 200) {
        console.log('✅ 公告API连接成功', response)
        ElMessage.success('公告API连接成功')
        return true
      } else {
        console.error('❌ 公告API返回错误:', response)
        ElMessage.error(`公告API错误: ${response.message}`)
        return false
      }
    } catch (error: any) {
      console.error('❌ 公告API连接失败:', error)
      ElMessage.error(`公告API连接失败: ${error.message}`)
      return false
    }
  }

  /**
   * 测试所有API连接
   */
  public async testAllApis(teamId: number): Promise<{
    project: boolean
    task: boolean
    announcement: boolean
    overall: boolean
  }> {
    console.log('🚀 开始测试所有API连接...')
    
    const results = {
      project: false,
      task: false,
      announcement: false,
      overall: false
    }

    // 测试项目API
    results.project = await this.testProjectApi(teamId)

    // 如果项目API成功，获取第一个项目来测试任务和公告API
    if (results.project) {
      try {
        const projectResponse = await projectApi.getTeamProjects(teamId)
        const projects = projectResponse.data || []
        
        if (projects.length > 0) {
          const firstProjectId = projects[0].id
          
          // 测试任务API
          results.task = await this.testTaskApi(firstProjectId)
          
          // 测试公告API
          results.announcement = await this.testAnnouncementApi(firstProjectId)
        } else {
          console.log('⚠️ 没有项目数据，跳过任务和公告API测试')
          ElMessage.warning('没有项目数据，无法测试任务和公告API')
        }
      } catch (error) {
        console.error('❌ 获取项目数据失败:', error)
      }
    }

    // 计算总体结果
    results.overall = results.project && results.task && results.announcement

    // 显示测试结果
    this.showTestResults(results)

    return results
  }

  /**
   * 显示测试结果
   */
  private showTestResults(results: {
    project: boolean
    task: boolean
    announcement: boolean
    overall: boolean
  }) {
    console.log('📊 API连接测试结果:')
    console.log(`  项目API: ${results.project ? '✅ 成功' : '❌ 失败'}`)
    console.log(`  任务API: ${results.task ? '✅ 成功' : '❌ 失败'}`)
    console.log(`  公告API: ${results.announcement ? '✅ 成功' : '❌ 失败'}`)
    console.log(`  总体状态: ${results.overall ? '✅ 全部成功' : '❌ 部分失败'}`)

    if (results.overall) {
      ElMessage.success('🎉 所有API连接测试通过！')
    } else {
      ElMessage.error('⚠️ 部分API连接测试失败，请检查后端服务')
    }
  }

  /**
   * 测试创建项目
   */
  public async testCreateProject(teamId: number): Promise<boolean> {
    try {
      console.log('🔍 测试创建项目...')
      
      const testProject = {
        teamId,
        name: `测试项目_${Date.now()}`,
        description: '这是一个API连接测试项目',
        priority: 'MEDIUM'
      }

      const response = await projectApi.createProject(testProject)
      
      if (response.code === 200) {
        console.log('✅ 创建项目成功', response)
        ElMessage.success('创建项目测试成功')
        
        // 清理测试数据
        if (response.data?.id) {
          await this.cleanupTestProject(response.data.id)
        }
        
        return true
      } else {
        console.error('❌ 创建项目失败:', response)
        ElMessage.error(`创建项目失败: ${response.message}`)
        return false
      }
    } catch (error: any) {
      console.error('❌ 创建项目测试失败:', error)
      ElMessage.error(`创建项目测试失败: ${error.message}`)
      return false
    }
  }

  /**
   * 清理测试项目
   */
  private async cleanupTestProject(projectId: number) {
    try {
      await projectApi.deleteProject(projectId)
      console.log('🧹 测试项目已清理')
    } catch (error) {
      console.warn('⚠️ 清理测试项目失败:', error)
    }
  }

  /**
   * 检查API基础URL配置
   */
  public checkApiConfig(): {
    baseUrl: string
    isValid: boolean
    message: string
  } {
    const baseUrl = import.meta.env.VITE_API_BASE_URL || '/api'
    const isValid = !!baseUrl && baseUrl.length > 0
    
    const result = {
      baseUrl,
      isValid,
      message: isValid ? 'API基础URL配置正常' : 'API基础URL配置缺失'
    }

    console.log('🔧 API配置检查:', result)
    
    if (isValid) {
      ElMessage.info(`API基础URL: ${baseUrl}`)
    } else {
      ElMessage.error('API基础URL配置错误')
    }

    return result
  }
}

/**
 * 快捷方法：测试所有API
 */
export function testAllApis(teamId: number) {
  return ApiTester.getInstance().testAllApis(teamId)
}

/**
 * 快捷方法：测试项目API
 */
export function testProjectApi(teamId: number) {
  return ApiTester.getInstance().testProjectApi(teamId)
}

/**
 * 快捷方法：检查API配置
 */
export function checkApiConfig() {
  return ApiTester.getInstance().checkApiConfig()
}

/**
 * 快捷方法：测试创建项目
 */
export function testCreateProject(teamId: number) {
  return ApiTester.getInstance().testCreateProject(teamId)
}
